"""
统一解析器接口
提供INF和DMF文件的统一解析接口
"""

import os
from typing import Dict, List, Any, Optional, Union
from abc import ABC, abstractmethod

from .inf_parser import INFParser
from .dmf_parser import DMFParser


class BaseParser(ABC):
    """解析器基类"""
    
    @abstractmethod
    def parse_file(self, file_path: str) -> bool:
        """解析文件"""
        pass
    
    @abstractmethod
    def get_lines_data(self) -> List[Dict]:
        """获取线路数据"""
        pass
    
    @abstractmethod
    def get_buses_data(self) -> List[Dict]:
        """获取母线数据"""
        pass
    
    @abstractmethod
    def get_transformers_data(self) -> List[Dict]:
        """获取变压器数据"""
        pass


class UnifiedParser:
    """统一解析器，自动检测文件类型并使用相应的解析器"""
    
    def __init__(self):
        self.parser: Optional[BaseParser] = None
        self.file_type: Optional[str] = None
        self.file_path: Optional[str] = None
        
    def parse_file(self, file_path: str) -> bool:
        """
        解析文件，自动检测文件类型
        
        Args:
            file_path: 文件路径
            
        Returns:
            bool: 解析是否成功
        """
        self.file_path = file_path
        
        if not os.path.exists(file_path):
            print(f"文件不存在: {file_path}")
            return False
        
        # 根据文件扩展名确定文件类型
        file_ext = os.path.splitext(file_path)[1].lower()
        
        if file_ext == '.inf':
            self.file_type = 'INF'
            self.parser = INFParser()
        elif file_ext in ['.dmf', '.xml']:
            self.file_type = 'DMF'
            self.parser = DMFParser()
        else:
            print(f"不支持的文件类型: {file_ext}")
            return False
        
        # 执行解析
        success = self.parser.parse_file(file_path)
        if success:
            print(f"✓ {self.file_type}文件解析成功: {file_path}")
        else:
            print(f"✗ {self.file_type}文件解析失败: {file_path}")
            
        return success
    
    def get_lines_data(self) -> List[Dict]:
        """获取线路数据"""
        if self.parser is None:
            return []
        return self.parser.get_lines_data()
    
    def get_buses_data(self) -> List[Dict]:
        """获取母线数据"""
        if self.parser is None:
            return []
        return self.parser.get_buses_data()
    
    def get_transformers_data(self) -> List[Dict]:
        """获取变压器数据"""
        if self.parser is None:
            return []
        return self.parser.get_transformers_data()
    
    def get_file_type(self) -> Optional[str]:
        """获取文件类型"""
        return self.file_type
    
    def get_raw_data(self) -> Optional[Any]:
        """获取原始解析数据"""
        if self.parser is None:
            return None
            
        if hasattr(self.parser, 'get_raw_dmf_data'):
            return self.parser.get_raw_dmf_data()
        else:
            # INF parser doesn't have raw data method, return the parser itself
            return self.parser


class DeviceConfigManager:
    """设备配置管理器，提供统一的设备数据访问接口"""
    
    def __init__(self, base_path: str, file_name: str):
        """
        初始化设备配置管理器
        
        Args:
            base_path: 基础路径
            file_name: 文件名（不含扩展名）
        """
        self.base_path = base_path
        self.file_name = file_name
        self.inf_file = ''
        self.dmf_file = ''

        inf_file_ext = ['.inf', '.INF']
        for ext in inf_file_ext:
            if os.path.exists(os.path.join(base_path, f"{file_name}{ext}")):
                self.inf_file = os.path.join(base_path, f"{file_name}{ext}")
                break

        dmf_file_ext = ['.dmf', '.DMF']
        for ext in dmf_file_ext:
            if os.path.exists(os.path.join(base_path, f"{file_name}{ext}")):
                self.dmf_file = os.path.join(base_path, f"{file_name}{ext}")
                break
        
        self.parser: Optional[UnifiedParser] = None
        self.data_source: Optional[str] = None
        
    def load_config(self, prefer_dmf: bool = True) -> bool:
        """
        加载设备配置
        
        Args:
            prefer_dmf: 是否优先使用DMF文件
            
        Returns:
            bool: 加载是否成功
        """
        self.parser = UnifiedParser()
        
        # 确定文件优先级
        file_priority = [self.dmf_file, self.inf_file] if prefer_dmf else [self.inf_file, self.dmf_file]
        
        for file_path in file_priority:
            if os.path.exists(file_path):
                print(f"尝试解析文件: {file_path}")
                
                if self.parser.parse_file(file_path):
                    self.data_source = self.parser.get_file_type()
                    print(f"✓ 使用{self.data_source}文件作为数据源")
                    return True
                else:
                    print(f"✗ {file_path}解析失败，尝试下一个文件")
        
        print(f"✗ 未找到有效的配置文件 (尝试了: {[f for f in file_priority if os.path.exists(f)]})")
        return False
    
    def get_lines_data(self) -> List[Dict]:
        """获取线路数据"""
        if self.parser is None:
            return []
        return self.parser.get_lines_data()
    
    def get_buses_data(self) -> List[Dict]:
        """获取母线数据"""
        if self.parser is None:
            return []
        return self.parser.get_buses_data()
    
    def get_transformers_data(self) -> List[Dict]:
        """获取变压器数据"""
        if self.parser is None:
            return []
        return self.parser.get_transformers_data()
    
    def get_data_source(self) -> Optional[str]:
        """获取数据源类型"""
        return self.data_source
    
    def get_raw_data(self) -> Optional[Any]:
        """获取原始数据"""
        if self.parser is None:
            return None
        return self.parser.get_raw_data()
    
    def get_summary(self) -> Dict[str, Any]:
        """获取配置摘要"""
        if self.parser is None:
            return {
                'success': False,
                'data_source': None,
                'lines_count': 0,
                'buses_count': 0,
                'transformers_count': 0
            }
        
        lines_data = self.get_lines_data()
        buses_data = self.get_buses_data()
        transformers_data = self.get_transformers_data()
        
        return {
            'success': True,
            'data_source': self.data_source,
            'file_name': self.file_name,
            'lines_count': len(lines_data),
            'buses_count': len(buses_data),
            'transformers_count': len(transformers_data),
            'lines': [line.get('dev_name', 'Unknown') for line in lines_data],
            'buses': [bus.get('dev_name', 'Unknown') for bus in buses_data],
            'transformers': [trm.get('dev_name', 'Unknown') for trm in transformers_data]
        }


def auto_detect_and_parse(base_path: str, file_name: str, prefer_dmf: bool = True) -> Optional[DeviceConfigManager]:
    """
    自动检测并解析设备配置文件
    
    Args:
        base_path: 基础路径
        file_name: 文件名（不含扩展名）
        prefer_dmf: 是否优先使用DMF文件
        
    Returns:
        DeviceConfigManager: 配置管理器实例，失败时返回None
    """
    manager = DeviceConfigManager(base_path, file_name)
    
    if manager.load_config(prefer_dmf=prefer_dmf):
        return manager
    else:
        return None


# 使用示例
if __name__ == "__main__":
    # 示例1: 使用统一解析器
    print("=" * 60)
    print("统一解析器示例")
    print("=" * 60)
    
    parser = UnifiedParser()
    
    # 测试INF文件
    inf_file = "../data/2025-02-14_15-16-56_ACT_14576#录波装置.INF"
    if parser.parse_file(inf_file):
        lines = parser.get_lines_data()
        buses = parser.get_buses_data()
        transformers = parser.get_transformers_data()
        
        print(f"解析结果 ({parser.get_file_type()}):")
        print(f"  线路: {len(lines)} 条")
        print(f"  母线: {len(buses)} 个")
        print(f"  变压器: {len(transformers)} 个")
    
    # 示例2: 使用设备配置管理器
    print("\n" + "=" * 60)
    print("设备配置管理器示例")
    print("=" * 60)
    
    manager = auto_detect_and_parse(
        base_path="../data",
        file_name="2025-02-14_15-16-56_ACT_14576#录波装置",
        prefer_dmf=True
    )
    
    if manager:
        summary = manager.get_summary()
        print("配置摘要:")
        for key, value in summary.items():
            print(f"  {key}: {value}")
    else:
        print("配置加载失败")